var request = require('request');

/**
 * ## Responses
 * Responses from this API with be wrapped in an envelope to assist the caller
 * in dealing with the various responses from the service. There are no types
 * to check against in JavaScript, so this facilitates that.
 *
 *    {
 *      status: 200,
 *      data: { name: "John", age: 29 }
 *    }
 *
 * ## Logging
 * To enable logging, use the NODE_DEBUG environment variable.
 *
 *    NODE_DEBUG=apidoc
 *
 * @constructor
 */
function Apibuilderapi (host) {
  var showLogMessages = process.env.NODE_DEBUG ? process.env.NODE_DEBUG.indexOf('apidoc') !== -1 : false;

  function log (message) {
    if (showLogMessages) {
      console.log('[apidoc] ' + message);
    }
  }

  function getQueryString (options) {
    var params = [];
    var qs = options.qs || {};

    for (var key in qs) {
      if (qs[key]) {
        params.push(key + '=' + qs[key]);
      }
    }

    return params.join('&');
  }

  function doRequest (options) {
    var startMs = Date.now();
    options = options || {};

    if (!options.json) {
      options.json = true;
    }

    options.qsStringifyOptions = {
      arrayFormat: 'repeat'
    };

    var queryString = getQueryString(options);
    var url = options.uri + (queryString ? '?' + queryString : '');

    log(options.method + ' ' + url);
    if (options.method === 'POST' || options.method === 'PUT' || options.method === 'PATCH') {
      log('|--> With body:\n\t\t' + JSON.stringify(options.json));
    }

    return new Promise(function (resolve, reject) {
      request(options, function (err, response) {
        if (err) {
          reject(err);
          return;
        }

        var duration = Date.now() - startMs;
        var requestHref = response.request ? response.request.href : '<unknown url>';

        log('Completed ' + options.method + ' ' + requestHref + ' ' + response.statusCode + ' ' + duration + 'ms');

        resolve(response);
      });
    });
  }

  /**
   * Simple plain object check. This is actually really involved to be 100%
   * accurate
   */
  function isObject (obj) {
    return typeof obj === 'object' && !Array.isArray(obj);
  }

  var Applications = (function Applications() {
      /**
       * Search all applications. Results are always paginated.
       * 
       * @param {string} orgKey
       * @param {Object} options
       * @param {string} options.name
       * @param {string} options.guid
       * @param {string} options.key
       * @param {boolean} options.hasVersion
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function get(orgKey, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/' + orgKey + '';
        var queryString = {
          name: options.name,
          guid: options.guid,
          key: options.key,
          has_version: options.hasVersion,
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Create an application.
       * 
       * @param {string} orgKey
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(orgKey, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/' + orgKey + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Updates an application.
       * 
       * @param {string} orgKey
       * @param {string} applicationKey
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function putByApplicationKey(orgKey, applicationKey, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/' + orgKey + '/' + applicationKey + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'PUT'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Deletes a specific application and its associated versions.
       * 
       * @param {string} orgKey
       * @param {string} applicationKey
       */
      function deleteByApplicationKey(orgKey, applicationKey) {


        var url = host + '/' + orgKey + '/' + applicationKey + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'DELETE'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Moves application to a new organization.
       * 
       * @param {string} orgKey
       * @param {string} applicationKey
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postMoveByApplicationKey(orgKey, applicationKey, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/' + orgKey + '/' + applicationKey + '/move';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      get: get,
      post: post,
      putByApplicationKey: putByApplicationKey,
      deleteByApplicationKey: deleteByApplicationKey,
      postMoveByApplicationKey: postMoveByApplicationKey,
    };
  }());

  var Attributes = (function Attributes() {
      /**
       * Search all attributes. Results are always paginated.
       * 
       * @param {Object} options
       * @param {string} options.guid
       * @param {string} options.name
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function get(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/attributes';
        var queryString = {
          guid: options.guid,
          name: options.name,
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Returns the attribute with this name.
       * 
       * @param {string} name
       */
      function getByName(name) {


        var url = host + '/attributes/' + name + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Create a new attribute.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/attributes';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 201:
              return Promise.resolve(serverResponse.body);
            case 401:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Deletes the attribute with this name. Only the user who created an attribute can delete it.
       * 
       * @param {string} name
       */
      function deleteByName(name) {


        var url = host + '/attributes/' + name + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'DELETE'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            case 401:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      get: get,
      getByName: getByName,
      post: post,
      deleteByName: deleteByName,
    };
  }());

  var Authentications = (function Authentications() {
      /**
       * 
       * 
       * @param {string} id
       */
      function getSessionById(id) {


        var url = host + '/authentications/session/' + id + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      getSessionById: getSessionById,
    };
  }());

  var Changes = (function Changes() {
      /**
       * 
       * 
       * @param {Object} options
       * @param {string} options.orgKey
       * @param {string} options.applicationKey
       * @param {string} options.from
       * @param {string} options.to
       * @param {string} options.type
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function get(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/changes';
        var queryString = {
          org_key: options.orgKey,
          application_key: options.applicationKey,
          from: options.from,
          to: options.to,
          type: options.type,
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      get: get,
    };
  }());

  var Code = (function Code() {
      /**
       * Generate code for a specific version of an application.
       * 
       * @param {string} orgKey
       * @param {string} applicationKey
       * @param {string} version
       * @param {string} generatorKey
       */
      function getByApplicationKeyAndVersionAndGeneratorKey(orgKey, applicationKey, version, generatorKey) {


        var url = host + '/' + orgKey + '/' + applicationKey + '/' + version + '/' + generatorKey + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      getByApplicationKeyAndVersionAndGeneratorKey: getByApplicationKeyAndVersionAndGeneratorKey,
    };
  }());

  var Domains = (function Domains() {
      /**
       * Add a domain to this organization
       * 
       * @param {string} orgKey
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postByOrgKey(orgKey, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/domains/' + orgKey + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Remove this domain from this organization
       * 
       * @param {string} orgKey
       * @param {string} name
       */
      function deleteByOrgKeyAndName(orgKey, name) {


        var url = host + '/domains/' + orgKey + '/' + name + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'DELETE'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      postByOrgKey: postByOrgKey,
      deleteByOrgKeyAndName: deleteByOrgKeyAndName,
    };
  }());

  var EmailVerificationConfirmationForms = (function EmailVerificationConfirmationForms() {
      /**
       * Validate an email address using a token.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/email_verification_confirmations';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      post: post,
    };
  }());

  var GeneratorServices = (function GeneratorServices() {
      /**
       * List all generator services
       * 
       * @param {Object} options
       * @param {string} options.guid
       * @param {string} options.uri
       * @param {string} options.generatorKey
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function get(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/generator_services';
        var queryString = {
          guid: options.guid,
          uri: options.uri,
          generator_key: options.generatorKey,
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} guid
       */
      function getByGuid(guid) {


        var url = host + '/generator_services/' + guid + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/generator_services';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Deletes a generator service.
       * 
       * @param {string} guid
       */
      function deleteByGuid(guid) {


        var url = host + '/generator_services/' + guid + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'DELETE'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 403:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      get: get,
      getByGuid: getByGuid,
      post: post,
      deleteByGuid: deleteByGuid,
    };
  }());

  var GeneratorWithServices = (function GeneratorWithServices() {
      /**
       * List all available generators
       * 
       * @param {Object} options
       * @param {string} options.guid
       * @param {string} options.serviceGuid
       * @param {string} options.serviceUri
       * @param {string} options.attributeName
       * @param {string} options.key
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function get(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/generators';
        var queryString = {
          guid: options.guid,
          service_guid: options.serviceGuid,
          service_uri: options.serviceUri,
          attribute_name: options.attributeName,
          key: options.key,
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} key
       */
      function getByKey(key) {


        var url = host + '/generators/' + key + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      get: get,
      getByKey: getByKey,
    };
  }());

  var Healthchecks = (function Healthchecks() {
      /**
       * 
       * 
       */
      function getHealthcheck() {


        var url = host + '/_internal_/healthcheck';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       */
      function getMigrate() {


        var url = host + '/_internal_/migrate';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      getHealthcheck: getHealthcheck,
      getMigrate: getMigrate,
    };
  }());

  var Items = (function Items() {
      /**
       * 
       * 
       * @param {Object} options
       * @param {string} options.q
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function get(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/items';
        var queryString = {
          q: options.q,
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} guid
       */
      function getByGuid(guid) {


        var url = host + '/items/' + guid + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      get: get,
      getByGuid: getByGuid,
    };
  }());

  var Memberships = (function Memberships() {
      /**
       * Search all memberships. Results are always paginated.
       * 
       * @param {Object} options
       * @param {string} options.orgGuid
       * @param {string} options.orgKey
       * @param {string} options.userGuid
       * @param {string} options.role
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function get(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/memberships';
        var queryString = {
          org_guid: options.orgGuid,
          org_key: options.orgKey,
          user_guid: options.userGuid,
          role: options.role,
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} guid
       */
      function getByGuid(guid) {


        var url = host + '/memberships/' + guid + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} guid
       */
      function deleteByGuid(guid) {


        var url = host + '/memberships/' + guid + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'DELETE'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      get: get,
      getByGuid: getByGuid,
      deleteByGuid: deleteByGuid,
    };
  }());

  var MembershipRequests = (function MembershipRequests() {
      /**
       * Search all membership requests. Results are always paginated.
       * 
       * @param {Object} options
       * @param {string} options.orgGuid
       * @param {string} options.orgKey
       * @param {string} options.userGuid
       * @param {string} options.role
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function get(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/membership_requests';
        var queryString = {
          org_guid: options.orgGuid,
          org_key: options.orgKey,
          user_guid: options.userGuid,
          role: options.role,
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Create a membership request
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/membership_requests';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Accepts this membership request. User will become a member of the specified organization.
       * 
       * @param {string} guid
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postAcceptByGuid(guid, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/membership_requests/' + guid + '/accept';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Declines this membership request. User will NOT become a member of the specified organization.
       * 
       * @param {string} guid
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postDeclineByGuid(guid, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/membership_requests/' + guid + '/decline';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      get: get,
      post: post,
      postAcceptByGuid: postAcceptByGuid,
      postDeclineByGuid: postDeclineByGuid,
    };
  }());

  var Organizations = (function Organizations() {
      /**
       * Search all organizations. Results are always paginated.
       * 
       * @param {Object} options
       * @param {string} options.guid
       * @param {string} options.userGuid
       * @param {string} options.key
       * @param {string} options.name
       * @param {string} options.namespace
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function get(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/organizations';
        var queryString = {
          guid: options.guid,
          user_guid: options.userGuid,
          key: options.key,
          name: options.name,
          namespace: options.namespace,
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Returns the organization with this key.
       * 
       * @param {string} key
       */
      function getByKey(key) {


        var url = host + '/organizations/' + key + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Create a new organization.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/organizations';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Update an organization.
       * 
       * @param {string} key
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function putByKey(key, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/organizations/' + key + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'PUT'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Deletes an organization and all of its associated applications.
       * 
       * @param {string} key
       */
      function deleteByKey(key) {


        var url = host + '/organizations/' + key + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'DELETE'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Returns all attribute values for this organization. Results are always paginated.
       * 
       * @param {string} key
       * @param {Object} options
       * @param {string} options.name
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function getAttributesByKey(key, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/organizations/' + key + '/attributes';
        var queryString = {
          name: options.name,
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Returns the attribute value with this name.
       * 
       * @param {string} key
       * @param {string} name
       */
      function getAttributesByKeyAndName(key, name) {


        var url = host + '/organizations/' + key + '/attributes/' + name + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Create or update a new attribute value.
       * 
       * @param {string} key
       * @param {string} name
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function putAttributesByKeyAndName(key, name, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/organizations/' + key + '/attributes/' + name + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'PUT'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 201:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Deletes the attribute value with the specified name. Only the user who created an attribute value can delete it.
       * 
       * @param {string} key
       * @param {string} name
       */
      function deleteAttributesByKeyAndName(key, name) {


        var url = host + '/organizations/' + key + '/attributes/' + name + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'DELETE'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            case 401:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      get: get,
      getByKey: getByKey,
      post: post,
      putByKey: putByKey,
      deleteByKey: deleteByKey,
      getAttributesByKey: getAttributesByKey,
      getAttributesByKeyAndName: getAttributesByKeyAndName,
      putAttributesByKeyAndName: putAttributesByKeyAndName,
      deleteAttributesByKeyAndName: deleteAttributesByKeyAndName,
    };
  }());

  var PasswordResets = (function PasswordResets() {
      /**
       * Change the password for this token. If the token is invalid, has been used, or otherwise no longer can be applied, errors will be returned as 409s. A 204 represents that the user has successfully changed their password.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/password_resets';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      post: post,
    };
  }());

  var PasswordResetRequests = (function PasswordResetRequests() {
      /**
       * Create a new password reset. This will send the user an email with a link to reset their password.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/password_reset_requests';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      post: post,
    };
  }());

  var Subscriptions = (function Subscriptions() {
      /**
       * Search subscriptions. Always paginated.
       * 
       * @param {Object} options
       * @param {string} options.guid
       * @param {string} options.organizationKey
       * @param {string} options.userGuid
       * @param {*} options.publication
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function get(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/subscriptions';
        var queryString = {
          guid: options.guid,
          organization_key: options.organizationKey,
          user_guid: options.userGuid,
          publication: options.publication,
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Returns information about a specific subscription.
       * 
       * @param {string} guid
       */
      function getByGuid(guid) {


        var url = host + '/subscriptions/' + guid + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Create a new subscription.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/subscriptions';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 201:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} guid
       */
      function deleteByGuid(guid) {


        var url = host + '/subscriptions/' + guid + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'DELETE'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      get: get,
      getByGuid: getByGuid,
      post: post,
      deleteByGuid: deleteByGuid,
    };
  }());

  var Tokens = (function Tokens() {
      /**
       * 
       * 
       * @param {string} userGuid
       * @param {Object} options
       * @param {string} options.guid
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function getUsersByUserGuid(userGuid, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/tokens/users/' + userGuid + '';
        var queryString = {
          guid: options.guid,
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Used to fetch the clear text token.
       * 
       * @param {string} guid
       */
      function getCleartextByGuid(guid) {


        var url = host + '/tokens/' + guid + '/cleartext';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Create a new API token for this user
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/tokens';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 201:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} guid
       */
      function deleteByGuid(guid) {


        var url = host + '/tokens/' + guid + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'DELETE'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      getUsersByUserGuid: getUsersByUserGuid,
      getCleartextByGuid: getCleartextByGuid,
      post: post,
      deleteByGuid: deleteByGuid,
    };
  }());

  var Users = (function Users() {
      /**
       * Search for a specific user. You must specify at least 1 parameter - either a guid, email or token - and will receive back either 0 or 1 users.
       * 
       * @param {Object} options
       * @param {string} options.guid
       * @param {string} options.email
       * @param {string} options.token
       */
      function get(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/users';
        var queryString = {
          guid: options.guid,
          email: options.email,
          token: options.token,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Returns information about the user with this guid.
       * 
       * @param {string} guid
       */
      function getByGuid(guid) {


        var url = host + '/users/' + guid + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Used to authenticate a user with an email address and password. Successful authentication returns an instance of the user model. Failed authorizations of any kind are returned as a generic error with code user_authorization_failed.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postAuthenticate(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/users/authenticate';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Used to authenticate a user using a github access token. This is equivalent to running the following command to get the user info: curl -H &#x27;Authorization: Bearer code&#x27; https://api.github.com/user
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postAuthenticateGithub(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/users/authenticate_github';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Create a new user.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/users';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Updates information about the user with the specified guid.
       * 
       * @param {string} guid
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function putByGuid(guid, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/users/' + guid + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'PUT'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      get: get,
      getByGuid: getByGuid,
      postAuthenticate: postAuthenticate,
      postAuthenticateGithub: postAuthenticateGithub,
      post: post,
      putByGuid: putByGuid,
    };
  }());

  var Validations = (function Validations() {
      /**
       * 
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/validations';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      post: post,
    };
  }());

  var Versions = (function Versions() {
      /**
       * Search all versions of this application. Results are always paginated.
       * 
       * @param {string} orgKey
       * @param {string} applicationKey
       * @param {Object} options
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function getByApplicationKey(orgKey, applicationKey, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/' + orgKey + '/' + applicationKey + '';
        var queryString = {
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Retrieve a specific version of an application.
       * 
       * @param {string} orgKey
       * @param {string} applicationKey
       * @param {string} version
       */
      function getByApplicationKeyAndVersion(orgKey, applicationKey, version) {


        var url = host + '/' + orgKey + '/' + applicationKey + '/' + version + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Create a new version for an application
       * 
       * @param {string} orgKey
       * @param {string} version
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postByVersion(orgKey, version, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/' + orgKey + '/' + version + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Upsert a version of an application
       * 
       * @param {string} orgKey
       * @param {string} applicationKey
       * @param {string} version
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function putByApplicationKeyAndVersion(orgKey, applicationKey, version, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/' + orgKey + '/' + applicationKey + '/' + version + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'PUT'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Deletes a specific version.
       * 
       * @param {string} orgKey
       * @param {string} applicationKey
       * @param {string} version
       */
      function deleteByApplicationKeyAndVersion(orgKey, applicationKey, version) {


        var url = host + '/' + orgKey + '/' + applicationKey + '/' + version + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'DELETE'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Generates an example JSON document of the type with the specified name.
       * 
       * @param {string} orgKey
       * @param {string} applicationKey
       * @param {string} version
       * @param {string} typeName
       * @param {Object} options
       * @param {boolean} options.optionalFields
       */
      function getExampleByApplicationKeyAndVersionAndTypeName(orgKey, applicationKey, version, typeName, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/' + orgKey + '/' + applicationKey + '/' + version + '/example/' + typeName + '';
        var queryString = {
          optional_fields: options.optionalFields,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      getByApplicationKey: getByApplicationKey,
      getByApplicationKeyAndVersion: getByApplicationKeyAndVersion,
      postByVersion: postByVersion,
      putByApplicationKeyAndVersion: putByApplicationKeyAndVersion,
      deleteByApplicationKeyAndVersion: deleteByApplicationKeyAndVersion,
      getExampleByApplicationKeyAndVersionAndTypeName: getExampleByApplicationKeyAndVersionAndTypeName,
    };
  }());

  var Watches = (function Watches() {
      /**
       * Search attributes. Always paginated.
       * 
       * @param {Object} options
       * @param {string} options.guid
       * @param {string} options.userGuid
       * @param {string} options.organizationKey
       * @param {string} options.applicationKey
       * @param {number} options.limit
       * @param {number} options.offset
       */
      function get(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/watches';
        var queryString = {
          guid: options.guid,
          user_guid: options.userGuid,
          organization_key: options.organizationKey,
          application_key: options.applicationKey,
          limit: options.limit,
          offset: options.offset,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Returns information about a specific watch.
       * 
       * @param {string} guid
       */
      function getByGuid(guid) {


        var url = host + '/watches/' + guid + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Quick check if a user is watching a specific application.
       * 
       * @param {Object} options
       * @param {string} options.userGuid
       * @param {string} options.organizationKey
       * @param {string} options.applicationKey
       */
      function getCheck(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/watches/check';
        var queryString = {
          user_guid: options.userGuid,
          organization_key: options.organizationKey,
          application_key: options.applicationKey,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * Create a new watch.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/watches';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 201:
              return Promise.resolve(serverResponse.body);
            case 409:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} guid
       */
      function deleteByGuid(guid) {


        var url = host + '/watches/' + guid + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'DELETE'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      get: get,
      getByGuid: getByGuid,
      getCheck: getCheck,
      post: post,
      deleteByGuid: deleteByGuid,
    };
  }());

  this.Applications = Applications;
  this.Attributes = Attributes;
  this.Authentications = Authentications;
  this.Changes = Changes;
  this.Code = Code;
  this.Domains = Domains;
  this.EmailVerificationConfirmationForms = EmailVerificationConfirmationForms;
  this.GeneratorServices = GeneratorServices;
  this.GeneratorWithServices = GeneratorWithServices;
  this.Healthchecks = Healthchecks;
  this.Items = Items;
  this.Memberships = Memberships;
  this.MembershipRequests = MembershipRequests;
  this.Organizations = Organizations;
  this.PasswordResets = PasswordResets;
  this.PasswordResetRequests = PasswordResetRequests;
  this.Subscriptions = Subscriptions;
  this.Tokens = Tokens;
  this.Users = Users;
  this.Validations = Validations;
  this.Versions = Versions;
  this.Watches = Watches;
}



module.exports = Apibuilderapi;